﻿using HslCommunication;
using HslCommunication.Profinet.Siemens;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Windows;
using System.Windows.Media;
using TransControlSystem.Dao;
using TransControlSystem.Model;
using TransControlSystem.ViewModel.Common;

namespace TransControlSystem.View
{
    /// <summary>
    /// DemoTestWindow.xaml 的交互逻辑
    /// </summary>
    public partial class DemoTestWindow : Window
    {
        private Thread thread1 = null;
        private List<TagInfo> TagInfos = null;
        private bool IsStart = false;
        private readonly string PlcAddress = PlcHelper.GetPlcAddress();
        SiemensS7Net siemens = null;
        OperateResult connectPlc = null;
        public DemoTestWindow()
        {
            InitializeComponent();
            TagInfos = DapperTools.Query<TagInfo>("SELECT * FROM TagInfo where ReadOrWrite =1");
            thread1 = new Thread(new ThreadStart(AnalogPLCControl))
            {
                //转到后台线程
                IsBackground = true,
                //改变线程的优先级
                Priority = ThreadPriority.AboveNormal
            };
            thread1.Start();
        }

        /// <summary>
        /// 模拟
        /// </summary>
        private void AnalogPLCControl()
        {
            siemens = new SiemensS7Net(SiemensPLCS.S1500, PlcAddress);
            connectPlc = siemens.ConnectServer();
            while (true)
            {
                if (IsStart)
                {
                    ChangeText("开始模拟PLC！");
                    起始0秒("起始0秒，开始装铝料");
                    //10S
                    Thread.Sleep(10000);
                    第一次装铝料φ229完成生成任务1();

                    //20S
                    Thread.Sleep(15000);
                    任务1执行将1号堆垛位的铝料移至1号均质炉取料();

                    //30S
                    Thread.Sleep(15000);
                    任务1执行将1号堆垛位的铝料移至1号均质炉送料();

                    //40S
                    Thread.Sleep(10000);
                    任务1完成();

                    //50S
                    Thread.Sleep(10000);
                    第二次装铝料φ178完成生成任务2任务3任务4任务5();

                    //60S
                    Thread.Sleep(15000);
                    任务2执行将2号堆垛位的铝料移至2号均质炉取料();
                    //70S
                    Thread.Sleep(15000);
                    任务2执行将2号堆垛位的铝料移至2号均质炉送料();

                    //80s
                    Thread.Sleep(10000);
                    任务2完成();

                    //95S
                    Thread.Sleep(15000);
                    任务3执行将1号隔条仓的空隔条架子移至隔条总仓取料();

                    //105S
                    Thread.Sleep(15000);
                    任务3执行将1号隔条仓的空隔条架子移至隔条总仓送料();

                    //115S
                    Thread.Sleep(10000);
                    任务3完成();

                    //130S
                    Thread.Sleep(15000);
                    任务4执行将3号隔条仓的隔条移至1号隔条仓取料();

                    //140S
                    Thread.Sleep(15000);
                    任务4执行将3号隔条仓的隔条移至1号隔条仓送料();

                    //150S
                    Thread.Sleep(10000);
                    任务4完成();

                    //165S
                    Thread.Sleep(15000);
                    任务5执行将隔条总仓的空隔条架子移至3号隔条仓取料();

                    //175S
                    Thread.Sleep(15000);
                    任务5执行将隔条总仓的空隔条架子移至3号隔条仓送料();

                    //185S
                    Thread.Sleep(10000);
                    任务5完成();

                    //200S
                    Thread.Sleep(15000);
                    第三次装铝料φ229完成生成任务6();

                    //210S
                    Thread.Sleep(15000);
                    任务6执行将1号堆垛位的铝料移至3号均质炉取料();

                    //220S
                    Thread.Sleep(15000);
                    任务6执行将1号堆垛位的铝料移至3号均质炉送料();

                    //230S
                    Thread.Sleep(10000);
                    任务6完成();

                    //245S
                    Thread.Sleep(15000);
                    第四次装铝料φ229完成生成任务7();

                    //255S
                    Thread.Sleep(15000);
                    任务7执行将2号堆垛位的铝料移至4号均质炉取料();

                    //265S
                    Thread.Sleep(15000);
                    任务7执行将2号堆垛位的铝料移至4号均质炉送料();

                    //275S
                    Thread.Sleep(10000);
                    任务7完成();

                    //295S
                    Thread.Sleep(20000);
                    一号均值炉加热完成生成任务8();

                    //305S
                    Thread.Sleep(15000);
                    任务8执行将1号均质炉的铝料移至1号冷却室取料();

                    //315S
                    Thread.Sleep(15000);
                    任务8执行将1号均质炉的铝料移至1号冷却室送料();

                    //325S
                    Thread.Sleep(10000);
                    任务8完成();

                    //340S
                    Thread.Sleep(15000);
                    二号均值炉加热完成生成任务9();

                    //350S
                    Thread.Sleep(15000);
                    任务9执行将2号均质炉的铝料移至2号冷却室取料();

                    //360S
                    Thread.Sleep(15000);
                    任务9执行将2号均质炉的铝料移至2号冷却室送料();

                    //370S
                    Thread.Sleep(10000);
                    任务9完成();

                    //395S
                    Thread.Sleep(25000);
                    三号均值炉加热完成();

                    //415S
                    Thread.Sleep(20000);
                    四号均值炉加热完成();

                    //435S
                    Thread.Sleep(20000);
                    一号冷却室冷却完成生成任务10();

                    //445S
                    Thread.Sleep(10000);
                    任务10执行将1号冷却室的铝料移至1号解垛位取料生成任务11();

                    //455S
                    Thread.Sleep(15000);
                    任务10执行将1号冷却室的铝料移至1号解垛位送料();

                    //465S
                    Thread.Sleep(10000);
                    任务10完成();
                    //480S
                    Thread.Sleep(15000);
                    任务11执行将3号均质炉的铝料移至1号冷却室取料();

                    //490S
                    Thread.Sleep(15000);
                    任务11执行将3号均质炉的铝料移至1号冷却室送料();

                    //500S
                    Thread.Sleep(10000);
                    任务11完成();
                    //515
                    Thread.Sleep(15000);
                    二号冷却室冷却完成生成任务12();

                    //525S
                    Thread.Sleep(15000);
                    任务12执行将2号冷却室的铝料移至2号解垛位取料生成任务13();

                    //535S
                    Thread.Sleep(15000);
                    任务12执行将2号冷却室的铝料移至2号解垛位送料();

                    //545S
                    Thread.Sleep(10000);
                    任务12完成();



                    //560S
                    Thread.Sleep(15000);
                    任务13执行将4号均质炉的铝料移至2号冷却室取料();

                    //570S
                    Thread.Sleep(15000);
                    任务13执行将4号均质炉的铝料移至2号冷却室送料();

                    //580S
                    Thread.Sleep(10000);
                    任务13完成();

                    //595S
                    Thread.Sleep(15000);
                    一号解垛位仅剩隔条生成任务14();

                    //605S
                    Thread.Sleep(15000);
                    任务14执行将1号解垛位的底部隔条移至隔条总仓取料();

                    //615S
                    Thread.Sleep(15000);
                    任务14执行将1号解垛位的底部隔条移至隔条总仓送料();

                    //625S
                    Thread.Sleep(10000);
                    任务14完成();

                    //640S
                    Thread.Sleep(15000);
                    二号解垛位仅剩隔条();

                    //650S
                    Thread.Sleep(10000);
                    隔条总仓空生成任务15();

                    //660S
                    Thread.Sleep(15000);
                    任务15执行将2号解垛位的底部隔条移至隔条总仓取料();

                    //670S
                    Thread.Sleep(15000);
                    任务15执行将2号解垛位的底部隔条移至隔条总仓送料();

                    //685
                    Thread.Sleep(15000);
                    任务15完成();

                    //710S
                    Thread.Sleep(25000);
                    隔条总仓空();
                    ChangeText("模拟PLC结束！");
                    Thread.Sleep(5000);
                    Application.Current.Dispatcher.Invoke((Action)delegate ()
                    {
                        Label1.Text = "模拟内容展示";
                        Label1.ScrollToEnd();
                    });
                    //IsStart = false;
                    //Application.Current.Dispatcher.Invoke((Action)delegate ()
                    //{
                    //    Button_Init.Foreground = new SolidColorBrush(Colors.Black);//背景色
                    //    Button_Init.IsEnabled = true;
                    //    Button_Start.Foreground = new SolidColorBrush(Colors.Black);//背景色
                    //    Button_Start.IsEnabled = true;
                    //    Button_Stop.IsEnabled = false;
                    //    Button_Stop.Foreground = new SolidColorBrush(Colors.Red);//背景色
                    //});
                }
                else
                {
                    Application.Current.Dispatcher.Invoke((Action)delegate ()
                    {
                        Button_Stop.IsEnabled = false;
                        Button_Stop.Foreground = new SolidColorBrush(Colors.Red);//背景色
                    });
                }
                Thread.Sleep(500);
            }
        }

        private void ChangeText(string Text)
        {
            Application.Current.Dispatcher.Invoke((Action)delegate ()
            {
                Label1.Text = Label1.Text + "\r\n" + Text;
                Label1.ScrollToEnd();
            });
        }
        private void 起始0秒(string Text)
        {
            if (Text != "初始化")
            {
                ChangeText(Text);
            }
            else
            {
                Application.Current.Dispatcher.Invoke((Action)delegate ()
                {
                    Label1.Text = "模拟内容展示";
                });
            }
            TagInfo 一号隔条仓为空 = GetTaginfo("1#隔条仓为空");
            if (一号隔条仓为空.Value != "False")
            {
                一号隔条仓为空.Value = "False";
                WriteSiemensVal(一号隔条仓为空);
            }
            TagInfo 一号隔条仓层数 = GetTaginfo("1#隔条仓层数");
            一号隔条仓层数.Value = "15";
            WriteSiemensVal(一号隔条仓层数);


            TagInfo 二号隔条仓为空 = GetTaginfo("2#隔条仓为空");
            if (二号隔条仓为空.Value != "False")
            {
                二号隔条仓为空.Value = "False";
                WriteSiemensVal(二号隔条仓为空);
            }
            TagInfo 二号隔条仓层数 = GetTaginfo("2#隔条仓层数");
            二号隔条仓层数.Value = "15";
            WriteSiemensVal(二号隔条仓层数);

            TagInfo 一号堆垛位满 = GetTaginfo("1#堆垛位满");
            if (一号堆垛位满.Value != "False")
            {
                一号堆垛位满.Value = "False";
                WriteSiemensVal(一号堆垛位满);
            }
            TagInfo 一号铝垛堆叠层数 = GetTaginfo("1#铝垛堆叠层数");
            一号铝垛堆叠层数.Value = "0";
            WriteSiemensVal(一号铝垛堆叠层数);


            TagInfo 二号堆垛位满 = GetTaginfo("2#堆垛位满");
            if (二号堆垛位满.Value != "False")
            {
                二号堆垛位满.Value = "False";
                WriteSiemensVal(二号堆垛位满);
            }
            TagInfo 二号铝垛堆叠层数 = GetTaginfo("2#铝垛堆叠层数");
            二号铝垛堆叠层数.Value = "0";
            WriteSiemensVal(二号铝垛堆叠层数);


            TagInfo 隔条总仓空 = GetTaginfo("隔条总仓空");
            if (隔条总仓空.Value != "True")
            {
                隔条总仓空.Value = "True";
                WriteSiemensVal(隔条总仓空);
            }
            TagInfo 隔条总仓隔条层数 = GetTaginfo("隔条总仓隔条层数");
            隔条总仓隔条层数.Value = "0";
            WriteSiemensVal(隔条总仓隔条层数);


            TagInfo 一号均质炉有料 = GetTaginfo("1#均质炉有料");
            if (一号均质炉有料.Value != "False")
            {
                一号均质炉有料.Value = "False";
                WriteSiemensVal(一号均质炉有料);
            }
            TagInfo 一号均质炉加热完成 = GetTaginfo("1#均质炉加热完成");
            if (一号均质炉加热完成.Value != "False")
            {
                一号均质炉加热完成.Value = "False";
                WriteSiemensVal(一号均质炉加热完成);
            }


            TagInfo 二号均质炉有料 = GetTaginfo("2#均质炉有料");
            if (二号均质炉有料.Value != "False")
            {
                二号均质炉有料.Value = "False";
                WriteSiemensVal(二号均质炉有料);
            }
            TagInfo 二号均质炉加热完成 = GetTaginfo("2#均质炉加热完成");
            if (二号均质炉加热完成.Value != "False")
            {
                二号均质炉加热完成.Value = "False";
                WriteSiemensVal(二号均质炉加热完成);
            }


            TagInfo 三号均质炉有料 = GetTaginfo("3#均质炉有料");
            if (三号均质炉有料.Value != "False")
            {
                三号均质炉有料.Value = "False";
                WriteSiemensVal(三号均质炉有料);
            }
            TagInfo 三号均质炉加热完成 = GetTaginfo("3#均质炉加热完成");
            if (三号均质炉加热完成.Value != "False")
            {
                三号均质炉加热完成.Value = "False";
                WriteSiemensVal(三号均质炉加热完成);
            }


            TagInfo 四号均质炉有料 = GetTaginfo("4#均质炉有料");
            if (四号均质炉有料.Value != "False")
            {
                四号均质炉有料.Value = "False";
                WriteSiemensVal(四号均质炉有料);
            }
            TagInfo 四号均质炉加热完成 = GetTaginfo("4#均质炉加热完成");
            if (四号均质炉加热完成.Value != "False")
            {
                四号均质炉加热完成.Value = "False";
                WriteSiemensVal(四号均质炉加热完成);
            }


            TagInfo 一号均冷却室有料 = GetTaginfo("1#冷却室有料");
            if (一号均冷却室有料.Value != "False")
            {
                一号均冷却室有料.Value = "False";
                WriteSiemensVal(一号均冷却室有料);
            }
            TagInfo 一号均冷却室冷却完成 = GetTaginfo("1#冷却室冷却完成");
            if (一号均冷却室冷却完成.Value != "False")
            {
                一号均冷却室冷却完成.Value = "False";
                WriteSiemensVal(一号均冷却室冷却完成);
            }


            TagInfo 二号均冷却室有料 = GetTaginfo("2#冷却室有料");
            if (二号均冷却室有料.Value != "False")
            {
                二号均冷却室有料.Value = "False";
                WriteSiemensVal(二号均冷却室有料);
            }
            TagInfo 二号均冷却室冷却完成 = GetTaginfo("2#冷却室冷却完成");
            if (二号均冷却室冷却完成.Value != "False")
            {
                二号均冷却室冷却完成.Value = "False";
                WriteSiemensVal(二号均冷却室冷却完成);
            }


            TagInfo 一号解垛位空垛 = GetTaginfo("1#解垛位空垛");
            if (一号解垛位空垛.Value != "True")
            {
                一号解垛位空垛.Value = "True";
                WriteSiemensVal(一号解垛位空垛);
            }
            TagInfo 一号解垛位仅剩隔条 = GetTaginfo("1#解垛位仅剩隔条");
            if (一号解垛位仅剩隔条.Value != "False")
            {
                一号解垛位仅剩隔条.Value = "False";
                WriteSiemensVal(一号解垛位仅剩隔条);
            }


            TagInfo 二号解垛位空垛 = GetTaginfo("2#解垛位空垛");
            if (二号解垛位空垛.Value != "True")
            {
                二号解垛位空垛.Value = "True";
                WriteSiemensVal(二号解垛位空垛);
            }
            TagInfo 二号解垛位仅剩隔条 = GetTaginfo("2#解垛位仅剩隔条");
            if (二号解垛位仅剩隔条.Value != "False")
            {
                二号解垛位仅剩隔条.Value = "False";
                WriteSiemensVal(二号解垛位仅剩隔条);
            }


            TagInfo 三号解垛位空垛 = GetTaginfo("3#解垛位空垛");
            if (三号解垛位空垛.Value != "True")
            {
                三号解垛位空垛.Value = "True";
                WriteSiemensVal(三号解垛位空垛);
            }
            TagInfo 三号解垛位仅剩隔条 = GetTaginfo("3#解垛位仅剩隔条");
            if (三号解垛位仅剩隔条.Value != "False")
            {
                三号解垛位仅剩隔条.Value = "False";
                WriteSiemensVal(三号解垛位仅剩隔条);
            }


            TagInfo 三号隔条仓满 = GetTaginfo("3#隔条仓满");
            if (三号隔条仓满.Value != "True")
            {
                三号隔条仓满.Value = "True";
                WriteSiemensVal(三号隔条仓满);
            }
            TagInfo 三号隔条仓空 = GetTaginfo("3#隔条仓空");
            if (三号隔条仓空.Value != "False")
            {
                三号隔条仓空.Value = "False";
                WriteSiemensVal(三号隔条仓空);
            }
            TagInfo 三号隔条仓层数 = GetTaginfo("3#隔条仓层数");
            三号隔条仓层数.Value = "15";
            WriteSiemensVal(三号隔条仓层数);

            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "9";
            WriteSiemensVal(加料车位置);


            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "False")
            {
                任务指令执行完成.Value = "False";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 第一次装铝料φ229完成生成任务1()
        {
            ChangeText("第一次装铝料φ229，完成，生成任务1");

            TagInfo 一号隔条仓层数 = GetTaginfo("1#隔条仓层数");
            一号隔条仓层数.Value = "8";
            WriteSiemensVal(一号隔条仓层数);


            TagInfo 一号堆垛位满 = GetTaginfo("1#堆垛位满");
            if (一号堆垛位满.Value != "True")
            {
                一号堆垛位满.Value = "True";
                WriteSiemensVal(一号堆垛位满);
            }
            TagInfo 一号铝垛堆叠层数 = GetTaginfo("1#铝垛堆叠层数");
            一号铝垛堆叠层数.Value = "7";
            WriteSiemensVal(一号铝垛堆叠层数);
        }

        private void 任务1执行将1号堆垛位的铝料移至1号均质炉取料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "3";
            WriteSiemensVal(加料车位置);

            ChangeText("任务1，执行将1#堆垛位的铝料移至1#均质炉,取料,位置:" + 加料车位置.Value);
            TagInfo 一号堆垛位满 = GetTaginfo("1#堆垛位满");
            if (一号堆垛位满.Value != "False")
            {
                一号堆垛位满.Value = "False";
                WriteSiemensVal(一号堆垛位满);
            }
            TagInfo 一号铝垛堆叠层数 = GetTaginfo("1#铝垛堆叠层数");
            一号铝垛堆叠层数.Value = "0";
            WriteSiemensVal(一号铝垛堆叠层数);


        }

        private void 任务1执行将1号堆垛位的铝料移至1号均质炉送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "7";
            WriteSiemensVal(加料车位置);

            ChangeText("任务1，执行将1#堆垛位的铝料移至1#均质炉,送料,位置:" + 加料车位置.Value);
            TagInfo 一号均质炉有料 = GetTaginfo("1#均质炉有料");
            if (一号均质炉有料.Value != "True")
            {
                一号均质炉有料.Value = "True";
                WriteSiemensVal(一号均质炉有料);
            }


        }

        private void 任务1完成()
        {
            ChangeText("任务1完成\r\n");
            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 第二次装铝料φ178完成生成任务2任务3任务4任务5()
        {
            ChangeText("第二次装铝料φ178，完成，生成任务2,任务3,任务4,任务5");

            TagInfo 一号隔条仓层数 = GetTaginfo("1#隔条仓层数");
            一号隔条仓层数.Value = "0";
            WriteSiemensVal(一号隔条仓层数);

            TagInfo 二号堆垛位满 = GetTaginfo("2#堆垛位满");
            if (二号堆垛位满.Value != "True")
            {
                二号堆垛位满.Value = "True";
                WriteSiemensVal(二号堆垛位满);
            }

            TagInfo 二号铝垛堆叠层数 = GetTaginfo("2#铝垛堆叠层数");
            二号铝垛堆叠层数.Value = "8";
            WriteSiemensVal(二号铝垛堆叠层数);
        }

        private void 任务2执行将2号堆垛位的铝料移至2号均质炉取料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "4";
            WriteSiemensVal(加料车位置);

            ChangeText("任务2，执行将2#堆垛位的铝料移至2#均质炉,取料,位置:" + 加料车位置.Value);
            TagInfo 二号堆垛位满 = GetTaginfo("2#堆垛位满");
            if (二号堆垛位满.Value != "False")
            {
                二号堆垛位满.Value = "False";
                WriteSiemensVal(二号堆垛位满);
            }

            TagInfo 二号铝垛堆叠层数 = GetTaginfo("2#铝垛堆叠层数");
            二号铝垛堆叠层数.Value = "0";
            WriteSiemensVal(二号铝垛堆叠层数);
        }

        private void 任务2执行将2号堆垛位的铝料移至2号均质炉送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "8";
            WriteSiemensVal(加料车位置);

            ChangeText("任务2，执行将2#堆垛位的铝料移至2#均质炉,送料,位置:" + 加料车位置.Value);
            TagInfo 二号均质炉有料 = GetTaginfo("2#均质炉有料");
            if (二号均质炉有料.Value != "True")
            {
                二号均质炉有料.Value = "True";
                WriteSiemensVal(二号均质炉有料);
            }
        }

        private void 任务2完成()
        {
            ChangeText("任务2完成\r\n");
            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 任务3执行将1号隔条仓的空隔条架子移至隔条总仓取料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "1";
            WriteSiemensVal(加料车位置);

            ChangeText("任务3，执行将1#隔条仓的空隔条架子移至隔条总仓,取料,位置:" + 加料车位置.Value);

            TagInfo 一号隔条仓为空 = GetTaginfo("1#隔条仓为空");
            if (一号隔条仓为空.Value != "True")
            {
                一号隔条仓为空.Value = "True";
                WriteSiemensVal(一号隔条仓为空);
            }


        }

        private void 任务3执行将1号隔条仓的空隔条架子移至隔条总仓送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "6";
            WriteSiemensVal(加料车位置);

            ChangeText("任务3，执行将1#隔条仓的空隔条架子移至隔条总仓,送料,位置:" + 加料车位置.Value);

            TagInfo 隔条总仓空 = GetTaginfo("隔条总仓空");
            if (隔条总仓空.Value != "False")
            {
                隔条总仓空.Value = "False";
                WriteSiemensVal(隔条总仓空);
            }
        }

        private void 任务3完成()
        {
            ChangeText("任务3完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 任务4执行将3号隔条仓的隔条移至1号隔条仓取料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "16";
            WriteSiemensVal(加料车位置);

            ChangeText("任务4，执行将3#隔条仓的隔条移至1#隔条仓,取料,位置:" + 加料车位置.Value);

            TagInfo 三号隔条仓满 = GetTaginfo("3#隔条仓满");
            if (三号隔条仓满.Value != "False")
            {
                三号隔条仓满.Value = "False";
                WriteSiemensVal(三号隔条仓满);
            }
            TagInfo 三号隔条仓空 = GetTaginfo("3#隔条仓空");
            if (三号隔条仓空.Value != "True")
            {
                三号隔条仓空.Value = "True";
                WriteSiemensVal(三号隔条仓空);
            }
            TagInfo 三号隔条仓层数 = GetTaginfo("3#隔条仓层数");
            三号隔条仓层数.Value = "0";
            WriteSiemensVal(三号隔条仓层数);
        }

        private void 任务4执行将3号隔条仓的隔条移至1号隔条仓送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "1";
            WriteSiemensVal(加料车位置);

            ChangeText("任务4，执行将3#隔条仓的隔条移至1#隔条仓,送料,位置:" + 加料车位置.Value);

            TagInfo 一号隔条仓为空 = GetTaginfo("1#隔条仓为空");
            if (一号隔条仓为空.Value != "False")
            {
                一号隔条仓为空.Value = "False";
                WriteSiemensVal(一号隔条仓为空);
            }
            TagInfo 一号隔条仓层数 = GetTaginfo("1#隔条仓层数");
            一号隔条仓层数.Value = "15";
            WriteSiemensVal(一号隔条仓层数);
        }

        private void 任务4完成()
        {
            ChangeText("任务4完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 任务5执行将隔条总仓的空隔条架子移至3号隔条仓取料()
        {

            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "6";
            WriteSiemensVal(加料车位置);

            ChangeText("任务5，执行将隔条总仓的空隔条架子移至3#隔条仓,取料,位置:" + 加料车位置.Value);

            TagInfo 隔条总仓空 = GetTaginfo("隔条总仓空");
            if (隔条总仓空.Value != "True")
            {
                隔条总仓空.Value = "True";
                WriteSiemensVal(隔条总仓空);
            }
        }

        private void 任务5执行将隔条总仓的空隔条架子移至3号隔条仓送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "16";
            WriteSiemensVal(加料车位置);

            ChangeText("任务5，执行将隔条总仓的空隔条架子移至3#隔条仓,送料,位置:" + 加料车位置.Value);

            TagInfo 三号隔条仓空 = GetTaginfo("3#隔条仓空");
            if (三号隔条仓空.Value != "False")
            {
                三号隔条仓空.Value = "False";
                WriteSiemensVal(三号隔条仓空);
            }
            TagInfo 三号隔条仓层数 = GetTaginfo("3#隔条仓层数");
            三号隔条仓层数.Value = "0";
            WriteSiemensVal(三号隔条仓层数);
        }

        private void 任务5完成()
        {
            ChangeText("任务5完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 第三次装铝料φ229完成生成任务6()
        {
            ChangeText("第三次装铝料φ229，完成，生成任务6");

            TagInfo 二号隔条仓层数 = GetTaginfo("2#隔条仓层数");
            二号隔条仓层数.Value = "8";
            WriteSiemensVal(二号隔条仓层数);

            TagInfo 一号堆垛位满 = GetTaginfo("1#堆垛位满");
            if (一号堆垛位满.Value != "True")
            {
                一号堆垛位满.Value = "True";
                WriteSiemensVal(一号堆垛位满);
            }

            TagInfo 一号铝垛堆叠层数 = GetTaginfo("1#铝垛堆叠层数");
            一号铝垛堆叠层数.Value = "7";
            WriteSiemensVal(一号铝垛堆叠层数);
        }

        private void 任务6执行将1号堆垛位的铝料移至3号均质炉取料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "3";
            WriteSiemensVal(加料车位置);

            ChangeText("任务6，执行将1#堆垛位的铝料移至3#均质炉,取料,位置:" + 加料车位置.Value);

            TagInfo 一号堆垛位满 = GetTaginfo("1#堆垛位满");
            if (一号堆垛位满.Value != "False")
            {
                一号堆垛位满.Value = "False";
                WriteSiemensVal(一号堆垛位满);
            }

            TagInfo 一号铝垛堆叠层数 = GetTaginfo("1#铝垛堆叠层数");
            一号铝垛堆叠层数.Value = "0";
            WriteSiemensVal(一号铝垛堆叠层数);
        }

        private void 任务6执行将1号堆垛位的铝料移至3号均质炉送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "10";
            WriteSiemensVal(加料车位置);

            ChangeText("任务6，执行将1#堆垛位的铝料移至3#均质炉,送料,位置:" + 加料车位置.Value);

            TagInfo 三号均质炉有料 = GetTaginfo("3#均质炉有料");
            if (三号均质炉有料.Value != "True")
            {
                三号均质炉有料.Value = "True";
                WriteSiemensVal(三号均质炉有料);
            }
        }

        private void 任务6完成()
        {
            ChangeText("任务6完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 第四次装铝料φ229完成生成任务7()
        {
            ChangeText("第四次装铝料φ229，完成,生成任务7");

            TagInfo 二号隔条仓层数 = GetTaginfo("2#隔条仓层数");
            二号隔条仓层数.Value = "1";
            WriteSiemensVal(二号隔条仓层数);


            TagInfo 二号堆垛位满 = GetTaginfo("2#堆垛位满");
            if (二号堆垛位满.Value != "True")
            {
                二号堆垛位满.Value = "True";
                WriteSiemensVal(二号堆垛位满);
            }

            TagInfo 二号铝垛堆叠层数 = GetTaginfo("2#铝垛堆叠层数");
            二号铝垛堆叠层数.Value = "7";
            WriteSiemensVal(二号铝垛堆叠层数);
        }

        private void 任务7执行将2号堆垛位的铝料移至4号均质炉取料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "4";
            WriteSiemensVal(加料车位置);

            ChangeText("任务7，执行将2#堆垛位的铝料移至4#均质炉,取料,位置:" + 加料车位置.Value);

            TagInfo 二号堆垛位满 = GetTaginfo("2#堆垛位满");
            if (二号堆垛位满.Value != "False")
            {
                二号堆垛位满.Value = "False";
                WriteSiemensVal(二号堆垛位满);
            }

            TagInfo 二号铝垛堆叠层数 = GetTaginfo("2#铝垛堆叠层数");
            二号铝垛堆叠层数.Value = "0";
            WriteSiemensVal(二号铝垛堆叠层数);
        }

        private void 任务7执行将2号堆垛位的铝料移至4号均质炉送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "11";
            WriteSiemensVal(加料车位置);

            ChangeText("任务7，执行将2#堆垛位的铝料移至4#均质炉,送料,位置:" + 加料车位置.Value);

            TagInfo 四号均质炉有料 = GetTaginfo("4#均质炉有料");
            if (四号均质炉有料.Value != "True")
            {
                四号均质炉有料.Value = "True";
                WriteSiemensVal(四号均质炉有料);
            }
        }

        private void 任务7完成()
        {
            ChangeText("任务7完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        //private void 任务8初始化() {
        //    ChangeTetx("初始化");

        //    TagInfo 一号隔条仓为空 = GetTaginfo("1#隔条仓为空");
        //    if (一号隔条仓为空.Value != "False")
        //    {
        //        一号隔条仓为空.Value = "False";
        //        WriteSiemensVal(一号隔条仓为空);
        //    }
        //    TagInfo 一号隔条仓层数 = GetTaginfo("1#隔条仓层数");
        //    一号隔条仓层数.Value = "15";
        //    WriteSiemensVal(一号隔条仓层数);


        //    TagInfo 二号隔条仓为空 = GetTaginfo("2#隔条仓为空");
        //    if (二号隔条仓为空.Value != "False")
        //    {
        //        二号隔条仓为空.Value = "False";
        //        WriteSiemensVal(二号隔条仓为空);
        //    }
        //    TagInfo 二号隔条仓层数 = GetTaginfo("2#隔条仓层数");
        //    二号隔条仓层数.Value = "1";
        //    WriteSiemensVal(二号隔条仓层数);

        //    TagInfo 一号堆垛位满 = GetTaginfo("1#堆垛位满");
        //    if (一号堆垛位满.Value != "False")
        //    {
        //        一号堆垛位满.Value = "False";
        //        WriteSiemensVal(一号堆垛位满);
        //    }
        //    TagInfo 一号铝垛堆叠层数 = GetTaginfo("1#铝垛堆叠层数");
        //    一号铝垛堆叠层数.Value = "0";
        //    WriteSiemensVal(一号铝垛堆叠层数);


        //    TagInfo 二号堆垛位满 = GetTaginfo("2#堆垛位满");
        //    if (二号堆垛位满.Value != "False")
        //    {
        //        二号堆垛位满.Value = "False";
        //        WriteSiemensVal(二号堆垛位满);
        //    }
        //    TagInfo 二号铝垛堆叠层数 = GetTaginfo("2#铝垛堆叠层数");
        //    二号铝垛堆叠层数.Value = "0";
        //    WriteSiemensVal(二号铝垛堆叠层数);


        //    TagInfo 隔条总仓空 = GetTaginfo("隔条总仓空");
        //    if (隔条总仓空.Value != "True")
        //    {
        //        隔条总仓空.Value = "True";
        //        WriteSiemensVal(隔条总仓空);
        //    }
        //    TagInfo 隔条总仓隔条层数 = GetTaginfo("隔条总仓隔条层数");
        //    隔条总仓隔条层数.Value = "0";
        //    WriteSiemensVal(隔条总仓隔条层数);


        //    TagInfo 一号均质炉有料 = GetTaginfo("1#均质炉有料");
        //    if (一号均质炉有料.Value != "True")
        //    {
        //        一号均质炉有料.Value = "True";
        //        WriteSiemensVal(一号均质炉有料);
        //    }
        //    TagInfo 一号均质炉加热完成 = GetTaginfo("1#均质炉加热完成");
        //    if (一号均质炉加热完成.Value != "False")
        //    {
        //        一号均质炉加热完成.Value = "False";
        //        WriteSiemensVal(一号均质炉加热完成);
        //    }


        //    TagInfo 二号均质炉有料 = GetTaginfo("2#均质炉有料");
        //    if (二号均质炉有料.Value != "True")
        //    {
        //        二号均质炉有料.Value = "True";
        //        WriteSiemensVal(二号均质炉有料);
        //    }
        //    TagInfo 二号均质炉加热完成 = GetTaginfo("2#均质炉加热完成");
        //    if (二号均质炉加热完成.Value != "False")
        //    {
        //        二号均质炉加热完成.Value = "False";
        //        WriteSiemensVal(二号均质炉加热完成);
        //    }


        //    TagInfo 三号均质炉有料 = GetTaginfo("3#均质炉有料");
        //    if (三号均质炉有料.Value != "True")
        //    {
        //        三号均质炉有料.Value = "True";
        //        WriteSiemensVal(三号均质炉有料);
        //    }
        //    TagInfo 三号均质炉加热完成 = GetTaginfo("3#均质炉加热完成");
        //    if (三号均质炉加热完成.Value != "False")
        //    {
        //        三号均质炉加热完成.Value = "False";
        //        WriteSiemensVal(三号均质炉加热完成);
        //    }


        //    TagInfo 四号均质炉有料 = GetTaginfo("4#均质炉有料");
        //    if (四号均质炉有料.Value != "True")
        //    {
        //        四号均质炉有料.Value = "True";
        //        WriteSiemensVal(四号均质炉有料);
        //    }
        //    TagInfo 四号均质炉加热完成 = GetTaginfo("4#均质炉加热完成");
        //    if (四号均质炉加热完成.Value != "False")
        //    {
        //        四号均质炉加热完成.Value = "False";
        //        WriteSiemensVal(四号均质炉加热完成);
        //    }


        //    TagInfo 一号均冷却室有料 = GetTaginfo("1#冷却室有料");
        //    if (一号均冷却室有料.Value != "False")
        //    {
        //        一号均冷却室有料.Value = "False";
        //        WriteSiemensVal(一号均冷却室有料);
        //    }
        //    TagInfo 一号均冷却室冷却完成 = GetTaginfo("1#冷却室冷却完成");
        //    if (一号均冷却室冷却完成.Value != "False")
        //    {
        //        一号均冷却室冷却完成.Value = "False";
        //        WriteSiemensVal(一号均冷却室冷却完成);
        //    }


        //    TagInfo 二号均冷却室有料 = GetTaginfo("2#冷却室有料");
        //    if (二号均冷却室有料.Value != "False")
        //    {
        //        二号均冷却室有料.Value = "False";
        //        WriteSiemensVal(二号均冷却室有料);
        //    }
        //    TagInfo 二号均冷却室冷却完成 = GetTaginfo("2#冷却室冷却完成");
        //    if (二号均冷却室冷却完成.Value != "False")
        //    {
        //        二号均冷却室冷却完成.Value = "False";
        //        WriteSiemensVal(二号均冷却室冷却完成);
        //    }


        //    TagInfo 一号解垛位空垛 = GetTaginfo("1#解垛位空垛");
        //    if (一号解垛位空垛.Value != "True")
        //    {
        //        一号解垛位空垛.Value = "True";
        //        WriteSiemensVal(一号解垛位空垛);
        //    }
        //    TagInfo 一号解垛位仅剩隔条 = GetTaginfo("1#解垛位仅剩隔条");
        //    if (一号解垛位仅剩隔条.Value != "False")
        //    {
        //        一号解垛位仅剩隔条.Value = "False";
        //        WriteSiemensVal(一号解垛位仅剩隔条);
        //    }


        //    TagInfo 二号解垛位空垛 = GetTaginfo("2#解垛位空垛");
        //    if (二号解垛位空垛.Value != "True")
        //    {
        //        二号解垛位空垛.Value = "True";
        //        WriteSiemensVal(二号解垛位空垛);
        //    }
        //    TagInfo 二号解垛位仅剩隔条 = GetTaginfo("2#解垛位仅剩隔条");
        //    if (二号解垛位仅剩隔条.Value != "False")
        //    {
        //        二号解垛位仅剩隔条.Value = "False";
        //        WriteSiemensVal(二号解垛位仅剩隔条);
        //    }


        //    TagInfo 三号解垛位空垛 = GetTaginfo("3#解垛位空垛");
        //    if (三号解垛位空垛.Value != "True")
        //    {
        //        三号解垛位空垛.Value = "True";
        //        WriteSiemensVal(三号解垛位空垛);
        //    }
        //    TagInfo 三号解垛位仅剩隔条 = GetTaginfo("3#解垛位仅剩隔条");
        //    if (三号解垛位仅剩隔条.Value != "False")
        //    {
        //        三号解垛位仅剩隔条.Value = "False";
        //        WriteSiemensVal(三号解垛位仅剩隔条);
        //    }


        //    TagInfo 三号隔条仓满 = GetTaginfo("3#隔条仓满");
        //    if (三号隔条仓满.Value != "True")
        //    {
        //        三号隔条仓满.Value = "True";
        //        WriteSiemensVal(三号隔条仓满);
        //    }
        //    TagInfo 三号隔条仓空 = GetTaginfo("3#隔条仓空");
        //    if (三号隔条仓空.Value != "False")
        //    {
        //        三号隔条仓空.Value = "False";
        //        WriteSiemensVal(三号隔条仓空);
        //    }
        //    TagInfo 三号隔条仓层数 = GetTaginfo("3#隔条仓层数");
        //    三号隔条仓层数.Value = "15";
        //    WriteSiemensVal(三号隔条仓层数);
        //}

        private void 一号均值炉加热完成生成任务8()
        {
            ChangeText("1#均值炉加热完成，生成任务8");

            TagInfo 一号均质炉加热完成 = GetTaginfo("1#均质炉加热完成");
            if (一号均质炉加热完成.Value != "True")
            {
                一号均质炉加热完成.Value = "True";
                WriteSiemensVal(一号均质炉加热完成);
            }
        }

        private void 任务8执行将1号均质炉的铝料移至1号冷却室取料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "7";
            WriteSiemensVal(加料车位置);

            ChangeText("任务8，执行将1#均质炉的铝料移至1#冷却室,取料,位置:" + 加料车位置.Value);

            TagInfo 一号均质炉有料 = GetTaginfo("1#均质炉有料");
            if (一号均质炉有料.Value != "False")
            {
                一号均质炉有料.Value = "False";
                WriteSiemensVal(一号均质炉有料);
            }

            TagInfo 一号均质炉加热完成 = GetTaginfo("1#均质炉加热完成");
            if (一号均质炉加热完成.Value != "False")
            {
                一号均质炉加热完成.Value = "False";
                WriteSiemensVal(一号均质炉加热完成);
            }
        }

        private void 任务8执行将1号均质炉的铝料移至1号冷却室送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "9";
            WriteSiemensVal(加料车位置);

            ChangeText("任务8，执行将1#均质炉的铝料移至1#冷却室,送料,位置:" + 加料车位置.Value);

            TagInfo 一号均冷却室有料 = GetTaginfo("1#冷却室有料");
            if (一号均冷却室有料.Value != "True")
            {
                一号均冷却室有料.Value = "True";
                WriteSiemensVal(一号均冷却室有料);
            }
        }

        private void 任务8完成()
        {
            ChangeText("任务8完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);

        }

        private void 二号均值炉加热完成生成任务9()
        {
            ChangeText("2#均值炉加热完成，生成任务9");

            TagInfo 二号均质炉加热完成 = GetTaginfo("2#均质炉加热完成");
            if (二号均质炉加热完成.Value != "True")
            {
                二号均质炉加热完成.Value = "True";
                WriteSiemensVal(二号均质炉加热完成);
            }
        }

        private void 任务9执行将2号均质炉的铝料移至2号冷却室取料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "8";
            WriteSiemensVal(加料车位置);

            ChangeText("任务9，执行将2#均质炉的铝料移至2#冷却室,取料,位置:" + 加料车位置.Value);

            TagInfo 二号均质炉有料 = GetTaginfo("2#均质炉有料");
            if (二号均质炉有料.Value != "False")
            {
                二号均质炉有料.Value = "False";
                WriteSiemensVal(二号均质炉有料);
            }

            TagInfo 二号均质炉加热完成 = GetTaginfo("2#均质炉加热完成");
            if (二号均质炉加热完成.Value != "False")
            {
                二号均质炉加热完成.Value = "False";
                WriteSiemensVal(二号均质炉加热完成);
            }
        }

        private void 任务9执行将2号均质炉的铝料移至2号冷却室送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "12";
            WriteSiemensVal(加料车位置);

            ChangeText("任务9，执行将2#均质炉的铝料移至2#冷却室,送料,位置:" + 加料车位置.Value);

            TagInfo 二号均冷却室有料 = GetTaginfo("2#冷却室有料");
            if (二号均冷却室有料.Value != "True")
            {
                二号均冷却室有料.Value = "True";
                WriteSiemensVal(二号均冷却室有料);
            }
        }

        private void 任务9完成()
        {
            ChangeText("任务9完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 三号均值炉加热完成()
        {
            ChangeText("3#均质炉加热完成\r\n");

            TagInfo 三号均值炉加热完成 = GetTaginfo("3#均质炉加热完成");
            if (三号均值炉加热完成.Value != "True")
            {
                三号均值炉加热完成.Value = "True";
                WriteSiemensVal(三号均值炉加热完成);
            }
        }

        private void 四号均值炉加热完成()
        {
            ChangeText("4#均值炉加热完成\r\n");

            TagInfo 四号均值炉加热完成 = GetTaginfo("4#均质炉加热完成");
            if (四号均值炉加热完成.Value != "True")
            {
                四号均值炉加热完成.Value = "True";
                WriteSiemensVal(四号均值炉加热完成);
            }
        }

        private void 一号冷却室冷却完成生成任务10()
        {
            ChangeText("1#冷却室冷却完成，生成任务10");

            TagInfo 一号均冷却室冷却完成 = GetTaginfo("1#冷却室冷却完成");
            if (一号均冷却室冷却完成.Value != "True")
            {
                一号均冷却室冷却完成.Value = "True";
                WriteSiemensVal(一号均冷却室冷却完成);
            }
        }

        private void 任务10执行将1号冷却室的铝料移至1号解垛位取料生成任务11()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "9";
            WriteSiemensVal(加料车位置);

            ChangeText("任务10，执行将1#冷却室的铝料移至1#解垛位,取料,生成任务11,位置:" + 加料车位置.Value);

            TagInfo 一号均冷却室有料 = GetTaginfo("1#冷却室有料");
            if (一号均冷却室有料.Value != "False")
            {
                一号均冷却室有料.Value = "False";
                WriteSiemensVal(一号均冷却室有料);
            }

            TagInfo 一号均冷却室冷却完成 = GetTaginfo("1#冷却室冷却完成");
            if (一号均冷却室冷却完成.Value != "False")
            {
                一号均冷却室冷却完成.Value = "False";
                WriteSiemensVal(一号均冷却室冷却完成);
            }
        }


        private void 任务10执行将1号冷却室的铝料移至1号解垛位送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "13";
            WriteSiemensVal(加料车位置);

            ChangeText("任务10，执行将1#冷却室的铝料移至1#解垛位,送料,位置:" + 加料车位置.Value);

            TagInfo 一号解垛位空垛 = GetTaginfo("1#解垛位空垛");
            if (一号解垛位空垛.Value != "False")
            {
                一号解垛位空垛.Value = "False";
                WriteSiemensVal(一号解垛位空垛);
            }
        }


        private void 任务10完成()
        {
            ChangeText("任务10完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 二号冷却室冷却完成生成任务12()
        {
            ChangeText("2#冷却室冷却完成,生成任务12");

            TagInfo 二号均冷却室冷却完成 = GetTaginfo("2#冷却室冷却完成");
            if (二号均冷却室冷却完成.Value != "True")
            {
                二号均冷却室冷却完成.Value = "True";
                WriteSiemensVal(二号均冷却室冷却完成);
            }

            TagInfo 二号解垛位空垛 = GetTaginfo("2#解垛位空垛");
            if (二号解垛位空垛.Value != "True")
            {
                二号解垛位空垛.Value = "True";
                WriteSiemensVal(二号解垛位空垛);
            }
        }

        private void 任务12执行将2号冷却室的铝料移至2号解垛位取料生成任务13()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "12";
            WriteSiemensVal(加料车位置);

            ChangeText("任务12，执行将2#冷却室的铝料移至2#解垛位,取料,生成任务13,位置:" + 加料车位置.Value);

            TagInfo 二号均冷却室有料 = GetTaginfo("2#冷却室有料");
            if (二号均冷却室有料.Value != "False")
            {
                二号均冷却室有料.Value = "False";
                WriteSiemensVal(二号均冷却室有料);
            }

            TagInfo 二号均冷却室冷却完成 = GetTaginfo("2#冷却室冷却完成");
            if (二号均冷却室冷却完成.Value != "False")
            {
                二号均冷却室冷却完成.Value = "False";
                WriteSiemensVal(二号均冷却室冷却完成);
            }
        }

        private void 任务12执行将2号冷却室的铝料移至2号解垛位送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "14";
            WriteSiemensVal(加料车位置);

            ChangeText("任务12，执行将2#冷却室的铝料移至2#解垛位,送料,位置:" + 加料车位置.Value);

            TagInfo 二号解垛位空垛 = GetTaginfo("2#解垛位空垛");
            if (二号解垛位空垛.Value != "False")
            {
                二号解垛位空垛.Value = "False";
                WriteSiemensVal(二号解垛位空垛);
            }
        }

        private void 任务12完成()
        {
            ChangeText("任务12完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 任务11执行将3号均质炉的铝料移至1号冷却室取料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "10";
            WriteSiemensVal(加料车位置);

            ChangeText("任务11，执行将3#均质炉的铝料移至1#冷却室,取料,位置:" + 加料车位置.Value);

            TagInfo 三号均质炉有料 = GetTaginfo("3#均质炉有料");
            if (三号均质炉有料.Value != "False")
            {
                三号均质炉有料.Value = "False";
                WriteSiemensVal(三号均质炉有料);
            }
            TagInfo 三号均质炉加热完成 = GetTaginfo("3#均质炉加热完成");
            if (三号均质炉加热完成.Value != "False")
            {
                三号均质炉加热完成.Value = "False";
                WriteSiemensVal(三号均质炉加热完成);
            }
        }

        private void 任务11执行将3号均质炉的铝料移至1号冷却室送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "9";
            WriteSiemensVal(加料车位置);

            ChangeText("任务11，执行将3#均质炉的铝料移至1#冷却室,送料,位置:" + 加料车位置.Value);

            TagInfo 一号均冷却室有料 = GetTaginfo("1#冷却室有料");
            if (一号均冷却室有料.Value != "True")
            {
                一号均冷却室有料.Value = "True";
                WriteSiemensVal(一号均冷却室有料);
            }
        }

        private void 任务11完成()
        {
            ChangeText("任务11完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 任务13执行将4号均质炉的铝料移至2号冷却室取料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "11";
            WriteSiemensVal(加料车位置);

            ChangeText("任务13，执行将4#均质炉的铝料移至2#冷却室,取料,位置:" + 加料车位置.Value);

            TagInfo 四号均质炉有料 = GetTaginfo("4#均质炉有料");
            if (四号均质炉有料.Value != "False")
            {
                四号均质炉有料.Value = "False";
                WriteSiemensVal(四号均质炉有料);
            }
            TagInfo 四号均质炉加热完成 = GetTaginfo("4#均质炉加热完成");
            if (四号均质炉加热完成.Value != "False")
            {
                四号均质炉加热完成.Value = "False";
                WriteSiemensVal(四号均质炉加热完成);
            }
        }

        private void 任务13执行将4号均质炉的铝料移至2号冷却室送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "12";
            WriteSiemensVal(加料车位置);

            ChangeText("任务13，执行将4#均质炉的铝料移至2#冷却室,送料,位置:" + 加料车位置.Value);

            TagInfo 二号均冷却室有料 = GetTaginfo("2#冷却室有料");
            if (二号均冷却室有料.Value != "True")
            {
                二号均冷却室有料.Value = "True";
                WriteSiemensVal(二号均冷却室有料);
            }
        }

        private void 任务13完成()
        {
            ChangeText("任务13完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 一号解垛位仅剩隔条生成任务14()
        {
            ChangeText("1#解垛位仅剩隔条，生成任务14");

            TagInfo 一号解垛位仅剩隔条 = GetTaginfo("1#解垛位仅剩隔条");
            if (一号解垛位仅剩隔条.Value != "True")
            {
                一号解垛位仅剩隔条.Value = "True";
                WriteSiemensVal(一号解垛位仅剩隔条);
            }



        }

        private void 任务14执行将1号解垛位的底部隔条移至隔条总仓取料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "13";
            WriteSiemensVal(加料车位置);

            ChangeText("任务14，执行将1#解垛位的底部隔条移至隔条总仓,取料,位置:" + 加料车位置.Value);

            TagInfo 一号解垛位空垛 = GetTaginfo("1#解垛位空垛");
            if (一号解垛位空垛.Value != "True")
            {
                一号解垛位空垛.Value = "True";
                WriteSiemensVal(一号解垛位空垛);
            }
            TagInfo 一号解垛位仅剩隔条 = GetTaginfo("1#解垛位仅剩隔条");
            if (一号解垛位仅剩隔条.Value != "False")
            {
                一号解垛位仅剩隔条.Value = "False";
                WriteSiemensVal(一号解垛位仅剩隔条);
            }
        }

        private void 任务14执行将1号解垛位的底部隔条移至隔条总仓送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "6";
            WriteSiemensVal(加料车位置);

            ChangeText("任务14，执行将1#解垛位的底部隔条移至隔条总仓,送料,位置:" + 加料车位置.Value);

            TagInfo 隔条总仓空 = GetTaginfo("隔条总仓空");
            if (隔条总仓空.Value != "False")
            {
                隔条总仓空.Value = "False";
                WriteSiemensVal(隔条总仓空);
            }
        }

        private void 任务14完成()
        {
            ChangeText("任务14完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 二号解垛位仅剩隔条()
        {
            ChangeText("2#解垛位仅剩隔条");

            TagInfo 二号解垛位仅剩隔条 = GetTaginfo("2#解垛位仅剩隔条");
            if (二号解垛位仅剩隔条.Value != "True")
            {
                二号解垛位仅剩隔条.Value = "True";
                WriteSiemensVal(二号解垛位仅剩隔条);
            }
        }

        private void 隔条总仓空生成任务15()
        {
            ChangeText("隔条总仓空，生成任务15");

            TagInfo 隔条总仓空 = GetTaginfo("隔条总仓空");
            if (隔条总仓空.Value != "True")
            {
                隔条总仓空.Value = "True";
                WriteSiemensVal(隔条总仓空);
            }
        }

        private void 任务15执行将2号解垛位的底部隔条移至隔条总仓取料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "14";
            WriteSiemensVal(加料车位置);

            ChangeText("任务15，执行将2#解垛位的底部隔条移至隔条总仓,取料,位置:" + 加料车位置.Value);

            TagInfo 二号解垛位空垛 = GetTaginfo("2#解垛位空垛");
            if (二号解垛位空垛.Value != "True")
            {
                二号解垛位空垛.Value = "True";
                WriteSiemensVal(二号解垛位空垛);
            }
            TagInfo 二号解垛位仅剩隔条 = GetTaginfo("2#解垛位仅剩隔条");
            if (二号解垛位仅剩隔条.Value != "False")
            {
                二号解垛位仅剩隔条.Value = "False";
                WriteSiemensVal(二号解垛位仅剩隔条);
            }
        }

        private void 任务15执行将2号解垛位的底部隔条移至隔条总仓送料()
        {
            TagInfo 加料车位置 = GetTaginfo("加料车位置");
            加料车位置.Value = "6";
            WriteSiemensVal(加料车位置);

            ChangeText("任务15，执行将2#解垛位的底部隔条移至隔条总仓,送料,位置:" + 加料车位置.Value);

            TagInfo 隔条总仓空 = GetTaginfo("隔条总仓空");
            if (隔条总仓空.Value != "False")
            {
                隔条总仓空.Value = "False";
                WriteSiemensVal(隔条总仓空);
            }
        }

        private void 任务15完成()
        {
            ChangeText("任务15完成\r\n");

            TagInfo 任务指令执行完成 = GetTaginfo("任务指令执行完成");
            if (任务指令执行完成.Value != "True")
            {
                任务指令执行完成.Value = "True";
            }
            WriteSiemensVal(任务指令执行完成);
        }

        private void 隔条总仓空()
        {
            ChangeText("隔条总仓空");

            TagInfo 隔条总仓空 = GetTaginfo("隔条总仓空");
            if (隔条总仓空.Value != "True")
            {
                隔条总仓空.Value = "True";
                WriteSiemensVal(隔条总仓空);
            }
        }

        private TagInfo GetTaginfo(string TagDesc)
        {
            TagInfo FindTag = null;
            for (int i = 0; i < TagInfos.Count; i++)
            {
                if (TagInfos[i].TagDesc == TagDesc)
                {
                    TagInfos[i].Value = GetSiemensVal(TagInfos[i].Address, TagInfos[i].ValueType);
                    FindTag = TagInfos[i];
                    break;
                }
            }
            return FindTag;
        }
        private string GetSiemensVal(string Address, string ValueType)
        {
            siemens = new SiemensS7Net(SiemensPLCS.S1500, PlcAddress);
            connectPlc = siemens.ConnectServer();
            string Value = "";
            if (connectPlc.IsSuccess)
            {
                Value = ValueType == "Bool"
                    ? siemens.ReadBool(Address).Content.ToString()
                    : ValueType == "DInt"
                        ? siemens.ReadInt32(Address).Content.ToString()
                        : ValueType == "Int" ? siemens.ReadInt16(Address).Content.ToString() : "无法识别的数据类型";
            }
            siemens.ConnectClose();
            return Value;
        }
        /// <summary>
        /// 根据类型使用不同方式写入值 西门子专用。
        /// </summary>
        private void WriteSiemensVal(TagInfo tagInfo)
        {
            if (connectPlc.IsSuccess)
            {
                if (tagInfo.ValueType == "Bool")
                {
                    siemens.Write(tagInfo.Address, bool.Parse(tagInfo.Value.ToLower()));
                }
                else if (tagInfo.ValueType == "DInt")
                {
                    siemens.Write(tagInfo.Address, Int32.Parse(tagInfo.Value));
                }
                else if (tagInfo.ValueType == "Int")
                {
                    siemens.Write(tagInfo.Address, Int16.Parse(tagInfo.Value));
                }
            }
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            起始0秒("初始化");
        }

        private void Button_Click_1(object sender, RoutedEventArgs e)
        {
            IsStart = true;
            Application.Current.Dispatcher.Invoke((Action)delegate ()
            {
                Button_Init.IsEnabled = false;
                Button_Init.Foreground = new SolidColorBrush(Colors.Red);//背景色
                Button_Start.IsEnabled = false;
                Button_Start.Foreground = new SolidColorBrush(Colors.Red);//背景色
                Button_Stop.IsEnabled = true;
                Button_Stop.Foreground = new SolidColorBrush(Colors.Black);//背景色
            });
        }
        private void Button_Click_2(object sender, RoutedEventArgs e)
        {
            IsStart = false;
            Application.Current.Dispatcher.Invoke((Action)delegate ()
            {
                Button_Init.Foreground = new SolidColorBrush(Colors.Black);//背景色
                Button_Init.IsEnabled = true;
                Button_Start.IsEnabled = true;
                Button_Start.Foreground = new SolidColorBrush(Colors.Black);//背景色
                Button_Stop.IsEnabled = false;
                Button_Stop.Foreground = new SolidColorBrush(Colors.Red);//背景色
            });
        }

        private void Button_Click_3(object sender, RoutedEventArgs e)
        {
            string strAppFileName = Process.GetCurrentProcess().MainModule.FileName;
            Process myNewProcess = new Process();
            myNewProcess.StartInfo.FileName = strAppFileName;
            myNewProcess.StartInfo.WorkingDirectory = AppDomain.CurrentDomain.BaseDirectory;
            myNewProcess.Start();
            Environment.Exit(0);
        }
    }
}
